package com.zrc.japktool.apk.merge;

import pxb.android.Res_value;
import pxb.android.arsc.*;
import pxb.android.axml.Util;
import com.zrc.japktool.util.HexUtils;
import com.zrc.japktool.util.Zip4jUtil;

import java.io.*;
import java.nio.ByteBuffer;
import java.util.*;

/**
 * ARSC文件编辑器，支持对APK中的resources.arsc进行编辑操作
 */
public class ArscEditor {
    List<Pkg> pkgs;
    Pkg pkg;

    public ArscEditor(byte[] arscData) throws IOException {
        this.pkgs = new ArscParser(ByteBuffer.wrap(Objects.requireNonNull(arscData))).parse();
        if (pkgs == null || pkgs.isEmpty()) {
            throw new IOException("Arsc file is empty");
        }
        this.pkg = pkgs.get(0);
    }

    public ArscEditor(String apkPath) throws IOException {
        byte[] arscData = Zip4jUtil.readFileBytes(apkPath, "resources.arsc");
        this.pkgs = new ArscParser(ByteBuffer.wrap(Objects.requireNonNull(arscData))).parse();
        if (pkgs == null || pkgs.isEmpty()) {
            throw new IOException("Arsc file is empty");
        }
        this.pkg = pkgs.get(0);
    }

    /**
     * 保存修改到文件（保存前先清理无效资源）
     */
    public void save2ApkFile(String outApkPath) throws IOException {
        if (!outApkPath.endsWith(".apk")) {
            throw new IOException(outApkPath + " 路径错误，必须以.apk结尾...");
        }
        cleanNullSpecs(); // 保存前清理所有null元素，避免ArscWriter报错
        ArscWriter writer = new ArscWriter(pkgs);
        byte[] newData = writer.toByteArray();
        // 确保resources.arsc以STORE模式（未压缩）写入
        Zip4jUtil.writeFileBytes(outApkPath, "resources.arsc", newData, true);
    }

    /**
     * 保存修改到文件（保存前先清理无效资源）
     */
    public void save2ArscFile(String arscFilePaht) throws IOException {
        if (!arscFilePaht.endsWith(".arsc")) {
            throw new IOException(arscFilePaht + " 路径错误，必须以.arsc结尾...");
        }
        cleanNullSpecs(); // 保存前清理所有null元素，避免ArscWriter报错
        ArscWriter writer = new ArscWriter(pkgs);
        byte[] newData = writer.toByteArray();
        Util.writeFile(newData, new File(arscFilePaht));
    }

    public Map<String, String> merge(ArscEditor bEditor) throws IOException {
        Map<String, String> idMap = new HashMap<>(); // b_id:key, a_id:value
        List<ResEntry> resEntries = new ArrayList<>();
        // 遍历B的所有资源并合并到A
        for (Pkg bPkg : bEditor.pkgs) {
            if (bPkg == null) continue;
            for (Type bType : bPkg.types.values()) {
                if (bType == null) continue;
                for (ResSpec bSpec : bType.specs) {
                    if (bSpec == null || bSpec.name == null) continue;
                    this.addResource(bPkg, bType, bSpec, resEntries, idMap);
                }
            }
        }

        //修改ResEntry中的引用id
        for (ResEntry resEntry : resEntries) {
            for (Map.Entry<String, String> entry : idMap.entrySet()) {
                // 处理ResEntry.value中的引用ID替换
                if (resEntry.value instanceof Res_value) {
                    Res_value resValue = (Res_value) resEntry.value;
                    String key = String.format("0x%08x", resValue.data);
                    if (resValue.type == Res_value.TYPE_REFERENCE || resValue.type == Res_value.TYPE_ATTRIBUTE || resValue.type == Res_value.TYPE_STRING) {
                        try {
                            int oldId = Integer.decode(entry.getKey()); // 将映射中的旧ID（十六进制字符串）转为整数
                            if (resValue.data == oldId) {
                                resValue.data = Integer.decode(entry.getValue());// 如果当前Res_value的data是旧ID，则替换为新ID
                                //System.out.println("替换引用: " + entry.getKey() + " -> " + entry.getValue());
                            }
                        } catch (NumberFormatException e) {
                            // 忽略无效的ID格式（理论上不会出现，因为ID是自动生成的十六进制）
                            // e.printStackTrace();
                        }
                    }
                } else if (resEntry.value instanceof BagValue) {
                    BagValue bagValue = (BagValue) resEntry.value;
                    // 遍历BagValue中的所有条目（每个条目是Res_value）
                    for (Map.Entry<Integer, Res_value> bagEntry : bagValue.map) {
                        Res_value bagResValue = bagEntry.getValue();
                        if (bagResValue.type == Res_value.TYPE_REFERENCE || bagResValue.type == Res_value.TYPE_ATTRIBUTE || bagResValue.type == Res_value.TYPE_STRING) {
                            try {
                                int oldId = Integer.decode(entry.getKey());
                                if (bagResValue.data == oldId) {
                                    bagResValue.data = Integer.decode(entry.getValue()); // 如果当前Res_value的data是旧ID，则替换为新ID
                                    //System.out.println("替换引用: " + entry.getKey() + " -> " + entry.getValue());
                                }
                            } catch (NumberFormatException e) {
                                // 忽略无效格式
                                // e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
        return idMap;
    }

    /**
     * 清理所有Type.specs数组中的null元素，避免序列化时出错
     */
    private void cleanNullSpecs() {
        for (Pkg pkg : pkgs) {
            // 遍历所有资源类型（如string、drawable等）
            for (Type type : pkg.types.values()) {
                // 过滤specs数组中的null元素
                List<ResSpec> validSpecs = new ArrayList<>();
                for (ResSpec spec : type.specs) {
                    if (spec != null) {
                        validSpecs.add(spec);
                    }
                }
                // 重新构建specs数组（去掉null元素）
                type.specs = validSpecs.toArray(new ResSpec[0]);
            }
        }
    }

    /**
     * 添加资源（从另一个Type和ResSpec拷贝）并记录ID映射
     *
     * @param b_pkg      源资源所在的包
     * @param b_type     源资源的类型
     * @param b_spec     源资源的规格
     * @param resEntries 用于存储新增资源条目的列表
     * @param idMap      用于记录B→A资源ID映射的Map
     * @return 新增的资源信息，null表示添加失败
     */
    public void addResource(Pkg b_pkg, Type b_type, ResSpec b_spec, List<ResEntry> resEntries, Map<String, String> idMap) {
        if (pkgs == null || pkgs.isEmpty() || b_pkg == null) {
            return;
        }
        Pkg a_pkg = pkgs.get(0);
        if (a_pkg == null) {
            return;
        }

        // 1. 检查目标类型中是否已存在同名资源，避免冲突
        Type a_type = findOrCreateType(b_type.name);
        ResSpec existingSpec = findResSpec(a_type, b_spec.name);
        if (existingSpec != null) {
            String bId = HexUtils.addHex(b_pkg.id << 24, b_type.id << 16, b_spec.id);
            String aId = HexUtils.addHex(a_pkg.id << 24, a_type.id << 16, existingSpec.id);
            if (idMap != null && !bId.equals(aId)) {
                idMap.put(bId, aId);
            }
            return; // 无论ID是否相同，都不再添加重复名称的资源
        }

        // 2. 拷贝b_spec的信息到新的new_spec（确保ID唯一性）
        int new_spec_id = a_type.specs.length; // 新ID为当前数组长度（末尾添加）
        ResSpec new_spec = new ResSpec(new_spec_id);
        new_spec.updateName(b_spec.name); // 复制名称
        new_spec.flags = b_spec.flags; // 复制标志（如public属性）

        // 3. 扩容a_type.specs数组并添加新规格
        ResSpec[] newSpecs = Arrays.copyOf(a_type.specs, a_type.specs.length + 1);
        newSpecs[new_spec_id] = new_spec;
        a_type.specs = newSpecs;

        // 4. 处理配置和资源条目（深拷贝避免原对象引用）
        List<Object> objects=new ArrayList<>();
        for (Config b_config : b_type.configs) {
            // 4.1 查找或创建相同配置（基于配置ID字节数组判断）
            Config a_config = findSameConfig(a_type, b_config);
            if (a_config == null) {
                // 深拷贝配置ID（避免原配置修改影响）
                byte[] copiedId = Arrays.copyOf(b_config.id, b_config.id.length);
                a_config = new Config(copiedId);
                a_type.configs.add(a_config);
            }

            // 4.2 获取并复制资源条目（处理不同类型的value）
            ResEntry b_entry = b_config.resources.get(b_spec);
            if (b_entry != null) {
                // 重点修复：深拷贝时传入类型名称，确保dimen类型被正确处理
                Object copiedValue = deepCopyValue(b_entry.value, idMap, b_type.name,true);
                ResEntry a_entry = new ResEntry(b_entry.isPublic, copiedValue);
                a_config.resources.put(new_spec, a_entry);
                resEntries.add(a_entry);
                objects.add(objects);
            }
        }

        // 5. 生成并记录ID映射（核心修改）
        String bId = HexUtils.addHex(b_pkg.id << 24, b_type.id << 16, b_spec.id);
        String aId = HexUtils.addHex(a_pkg.id << 24, a_type.id << 16, new_spec.id);
        if (idMap != null) {
            idMap.put(bId, aId);
        }

        //修改引用类型的数据
        for (Object object : objects) {
            modifyRef(object,idMap);
        }
    }

    private void modifyRef(Object value, Map<String, String> idMap) {
        if (value == null) {
            return;
        }
        if (value instanceof Res_value) {
            Res_value original = (Res_value) value;
            if (original.type == Res_value.TYPE_REFERENCE) { // 处理引用类型（TYPE_REFERENCE = 0x01）
                int bRefId = original.data;
                String bRefIdStr = HexUtils.addHex(bRefId);
                if (idMap != null && idMap.containsKey(bRefIdStr)) {
                    String aRefIdStr = idMap.get(bRefIdStr);
                    original.data = Integer.decode(aRefIdStr);
                }
            }
        }
    }

    /**
     * 深拷贝资源值并转换引用（增强dimen类型处理）
     *
     * @param value    原始值
     * @param idMap    ID映射表（可为null）
     * @param typeName 资源类型（用于针对性处理）
     */
    private Object deepCopyValue(Object value, Map<String, String> idMap, String typeName,boolean isLog) {
        if (value == null) {
            return null;
        }

        // 处理Res_value类型（包括dimen的引用和值）
        if (value instanceof Res_value) {
            Res_value original = (Res_value) value;
            Res_value copy = new Res_value();
            // 关键修复：完整复制所有字段（尤其是data字段，dimen值存储在这里）
            copy.raw = original.raw;
            copy.type = original.type;
            copy.data = original.data; // 新增：复制维度数值
            // 深拷贝样式列表
            if (original.styles != null) {
                copy.styles = new ArrayList<>(original.styles);
            }
            if (original.type == Res_value.TYPE_FIRST_COLOR_INT || original.type == Res_value.TYPE_INT_COLOR_RGB8 || original.type == Res_value.TYPE_INT_COLOR_ARGB4 || original.type == Res_value.TYPE_INT_COLOR_RGB4) {

            } else if (original.type == Res_value.TYPE_REFERENCE) { // 处理引用类型（TYPE_REFERENCE = 0x01）
//                int bRefId = original.data;
//                String bRefIdStr = HexUtils.addHex(bRefId);
//                if (idMap != null && idMap.containsKey(bRefIdStr)) {
//                    String aRefIdStr = idMap.get(bRefIdStr);
//                    copy.data = Integer.decode(aRefIdStr);
//                }
            } else if (original.type == Res_value.TYPE_DIMENSION) { // 处理维度类型（TYPE_DIMENSION = 0x05）
                //if (typeName.equals("dimen")){// 验证维度值是否被正确复制
                //    System.out.println("dimen值复制: 0x" + Integer.toHexString(original.data) + " -> 0x" + Integer.toHexString(copy.data));
                //}
            } else if (original.type == Res_value.TYPE_ATTRIBUTE) { // 处理维度类型（TYPE_DIMENSION = 0x05）

            }
            return copy;
        } else if (value instanceof BagValue) { // 处理复杂资源包（如style）
            BagValue original = (BagValue) value;
            BagValue copy = new BagValue(original.parent);
            copy.map = new ArrayList<>();
            // 递归深拷贝每个条目
            for (Map.Entry<Integer, Res_value> entry : original.map) {
                Res_value copiedVal = (Res_value) deepCopyValue(entry.getValue(), idMap, typeName,isLog);
                copy.map.add(new AbstractMap.SimpleEntry<>(entry.getKey(), copiedVal));
            }
            return copy;
        }
        // 基本类型直接返回
        return value;
    }

    /**
     * 优化配置匹配逻辑（基于配置ID字节数组完全匹配）
     */
    private Config findSameConfig(Type a_type, Config targetConfig) {
        for (Config config : a_type.configs) {
            // 比较配置的ID字节数组（配置的唯一标识）
            if (Arrays.equals(config.id, targetConfig.id)) {
                return config;
            }
        }
        return null;
    }

    /**
     * 修改现有资源
     */
    public boolean modifyResource(String pkgName, String typeName, String resName, Object newValue) {
        Pkg pkg = findPackage(pkgName);
        if (pkg == null) return false;

        Type type = findType(typeName);
        if (type == null) return false;

        ResSpec spec = findResSpec(type, resName);
        if (spec == null) return false;

        for (Config config : type.configs) {
            ResEntry entry = config.resources.get(spec);
            if (entry != null) {
                entry.value = newValue;
            }
        }
        return true;
    }

    /**
     * 根据app在resource.arsc中id去修改appname的值
     */
    public void modifyAppName(String appName, String targetResId) {
        // 前置校验：包、类型为空或应用名称无效，直接返回
        if (pkg == null || pkg.types.isEmpty() || appName == null || appName.trim().isEmpty()) {
            return;
        }
        // 获取string类型资源（应用名称存于string类型）
        Type stringType = findType("string");
        if (stringType == null) {
            return;
        }
        // 遍历string类型下所有规格，按HexUtils格式生成ID并匹配
        ResSpec targetSpec = null;
        for (ResSpec spec : stringType.specs) {
            if (spec == null) {
                continue;
            }
            // 按 HexUtils.addHex 格式生成当前资源的完整16进制ID（包ID+类型ID+规格ID）
            String currentResId = HexUtils.addHex(
                    pkg.id << 24,        // 包ID（高8位）
                    stringType.id << 16, // 类型ID（中8位）
                    spec.id              // 规格ID（低16位）
            );
            // 匹配目标ID，找到对应资源规格
            if (targetResId.equals(currentResId)) {
                targetSpec = spec;
                break;
            }
        }
        // 未找到目标规格，直接返回
        if (targetSpec == null) {
            return;
        }
        // 创建新应用名称的资源值，更新所有配置下的该资源
        Res_value newValue = Res_value.newStringValue(appName);
        for (Config cfg : stringType.configs) {
            ResEntry entry = cfg.resources.get(targetSpec);
            if (entry != null) {
                entry.value = newValue;
            }
        }
    }

    public Set<String> findLogoPath(List<String> hexIdList) {
        Set<String> paths = new HashSet<>();
        // 前置校验：空值/无效场景直接返回
        if (hexIdList == null || hexIdList.isEmpty() || pkg == null || pkg.types.isEmpty()) {
            return paths;
        }

        // 遍历 mipmap/drawable 两种图标可能的存储类型
        for (String resType : new String[]{"mipmap", "drawable"}) {
            Type targetType = findType(resType);
            if (targetType == null) continue;

            // 处理每个16进制ID（按HexUtils.addHex格式匹配）
            for (String targetHexId : hexIdList) {
                if (targetHexId == null || targetHexId.trim().isEmpty()) continue;

                // 遍历当前类型下所有资源规格，生成完整HexID并匹配
                for (ResSpec spec : targetType.specs) {
                    if (spec == null) continue;

                    // 按 HexUtils.addHex 格式生成当前资源的完整16进制ID
                    String currentHexId = HexUtils.addHex(
                            pkg.id << 24,    // 包ID（高8位）
                            targetType.id << 16,  // 类型ID（中8位）
                            spec.id         // 规格ID（低16位）
                    );

                    // 匹配目标ID，一致则提取路径
                    if (targetHexId.equals(currentHexId)) {
                        for (Config config : targetType.configs) {
                            ResEntry entry = config.resources.get(spec);
                            if (entry != null && entry.value instanceof Res_value) {
                                Res_value val = (Res_value) entry.value;
                                if (val.raw != null && !val.raw.trim().isEmpty()) {
                                    paths.add(val.raw);
                                }
                            }
                        }
                        break; // 找到匹配规格，跳出循环
                    }
                }
            }
        }
        return paths;
    }

    // 辅助方法：从字符串引用ID解析路径
    private String getPathFromStringReference(int stringRefId) {
        Type stringType = findType("string");
        if (stringType == null) return null;

        int specId = stringRefId & 0xFFFF;
        for (ResSpec spec : stringType.specs) {
            if (spec != null && spec.id == specId) {
                for (Config config : stringType.configs) {
                    ResEntry entry = config.resources.get(spec);
                    if (entry != null && entry.value instanceof Res_value) {
                        return ((Res_value) entry.value).raw;
                    }
                }
            }
        }
        return null;
    }

    /**
     * 删除资源（优化：删除后立即清理null元素，避免后续操作出错）
     */
    public boolean deleteResource(String pkgName, String typeName, String resName) {
        Pkg pkg = findPackage(pkgName);
        if (pkg == null) return false;

        Type type = findType(typeName);
        if (type == null) return false;

        ResSpec spec = findResSpec(type, resName);
        if (spec == null) return false;

        // 从规格数组中移除
        if (spec.id < type.specs.length) {
            type.specs[spec.id] = null;
        }

        // 从所有配置中移除
        for (Config config : type.configs) {
            config.resources.remove(spec);
        }

        // 立即清理当前Type中的null元素（避免数组中留存null）
        cleanTypeSpecs(type);
        return true;
    }

    /**
     * 清理单个Type中的null元素
     */
    private void cleanTypeSpecs(Type type) {
        List<ResSpec> validSpecs = new ArrayList<>();
        for (ResSpec spec : type.specs) {
            if (spec != null) {
                validSpecs.add(spec);
            }
        }
        type.specs = validSpecs.toArray(new ResSpec[0]);
    }

    /**
     * 按名称查找包
     */
    private Pkg findPackage(String pkgName) {
        for (Pkg pkg : pkgs) {
            if (pkgName.equals(pkg.name)) {
                return pkg;
            }
        }
        return null;
    }

    /**
     * 按名称查找或创建包
     */
    private Pkg findOrCreatePackage(String pkgName) {
        Pkg pkg = findPackage(pkgName);
        if (pkg == null) {
            int pkgId = 0x7f;
            while (isPackageIdInUse(pkgId)) {
                pkgId++;
            }
            pkg = new Pkg(pkgId, pkgName);
            pkgs.add(pkg);
        }
        return pkg;
    }

    /**
     * 检查包ID是否已被使用
     */
    private boolean isPackageIdInUse(int pkgId) {
        for (Pkg pkg : pkgs) {
            if (pkg.id == pkgId) {
                return true;
            }
        }
        return false;
    }

    /**
     * 查找类型
     */
    private Type findType(String typeName) {
        for (Type type : pkg.types.values()) {
            if (typeName.equals(type.name)) {
                return type;
            }
        }
        return null;
    }

    /**
     * 查找或创建类型
     */
    private Type findOrCreateType(String typeName) {
        Type type = findType(typeName);
        if (type == null) {
            int typeId = 1;
            while (pkg.types.containsKey(typeId)) {
                typeId++;
            }
            type = new Type();
            type.id = typeId;
            type.name = typeName;
            type.specs = new ResSpec[0]; // 初始化为空数组（避免默认空元素）
            pkg.types.put(typeId, type);
        }
        return type;
    }

    /**
     * 查找资源规格
     */
    private ResSpec findResSpec(Type type, String resName) {
        for (ResSpec spec : type.specs) {
            if (spec != null && resName.equals(spec.name)) {
                return spec;
            }
        }
        return null;
    }

    /**
     * 创建ResSpecId
     */
    private int creatResSpecId(Type type) {
        return type.specs.length;//新ID在末尾添加
    }

    /**
     * 查找或创建默认配置
     */
    private Config findOrCreateDefaultConfig(Type type) {
        if (type.configs.isEmpty()) {
            Config config = new Config(new byte[0]);
            type.addConfig(config);
            return config;
        }
        return type.configs.get(0);
    }

    /**
     * 打印resources.arsc的详细信息
     */
    public void printArscInfo() {
        System.out.println("============================== resources.arsc 信息 ==============================");
        System.out.println("Pkgs-> " + " pkgsCount:" + pkgs.size());
        for (int i = 0; i < pkgs.size(); i++) {
            Pkg pkg = pkgs.get(i);
            System.out.println("    Pkg-> " + pkg.name + " id: " + HexUtils.addHex(pkg.id << 24) + " typesCount: " + pkg.types.size());
            for (Type type : pkg.types.values()) {
                if (!type.name.equals("style")) continue;
                System.out.println("        Type-> " + type.name + " id: " + HexUtils.addHex(pkg.id << 24, type.id << 16) + " specsCount: " + type.specs.length + " configsCount: " + type.configs.size());
                for (ResSpec spec : type.specs) {
                    if (spec == null) continue;
                    System.out.println("            ResSpec-> " + spec.name + " id: " + HexUtils.addHex(pkg.id << 24, type.id << 16, spec.id));
                    for (Config config : type.configs) {
                        ResEntry entry = config.resources.get(spec);
                        if (entry != null) {
                            System.out.println("                Config-> " + spec.name + " value: " + entry.value);
                        }
                    }
                }
            }
        }
        System.out.println("========================= 信息打印完毕 ==============================");
    }

    public void printArscInfo2() {
        System.out.println("============================== resources.arsc 信息 ==============================");
        System.out.println("Pkgs-> " + " pkgsCount:" + pkgs.size());
        for (int i = 0; i < pkgs.size(); i++) {
            Pkg pkg = pkgs.get(i);
            System.out.println("    Pkg-> " + pkg.name + " id: " + HexUtils.addHex(pkg.id << 24) + " typesCount: " + pkg.types.size());
            for (Type type : pkg.types.values()) {
                if (!type.name.equals("dimen")) continue;
                System.out.println("        Type-> " + type.name + " id: " + HexUtils.addHex(pkg.id << 24, type.id << 16) + " specsCount: " + type.specs.length + " configsCount: " + type.configs.size());
                for (ResSpec spec : type.specs) {
                    if (spec == null) continue;
                    System.out.println("            ResSpec-> " + spec.name + " id: " + HexUtils.addHex(pkg.id << 24, type.id << 16, spec.id));
                    for (Config config : type.configs) {
                        ResEntry entry = config.resources.get(spec);
                        if (entry != null) {
                            System.out.println("                Config-> " + spec.name + " value: " + entry.value);
                        }
                    }
                }
            }
        }
        System.out.println("========================= 信息打印完毕 ==============================");
    }

    /**
     * 使用示例
     */
    public static void main(String[] args) {
        try {
            // 加载APK文件
            byte[] arscData = Zip4jUtil.readFileBytes("C:/Users/Administrator/Desktop/test/B.apk", "resources.arsc");
            ArscEditor editor = new ArscEditor(arscData);
            // 添加字符串资源，使用包名而非ID
            // 0x7f010020
            //editor.addResource("com.gtsy.annoying.punch.game", "anim", "a_tt_text_animation_y_out", Res_value.newStringValue("res/anim/tt_text_animation_y_out.xml"));

            //editor.addResource( "string", "new_string", Res_value.newStringValue("Hello World"));
            // 修改现有资源
            //editor.modifyResource("com.gtsy.annoying.punch.game", "string", "app_name", Res_value.newStringValue("大丈夫..."));
            // 删除资源
            //editor.deleteResource("com.gtsy.annoying.punch.game", "string", "new_string");
            // 保存修改


            //diemen表格的处理方案
            //editor.addResource("dimen", "testId",Res_value.newReference(0x7f0600a1));         //添加引用类型的值 样式[@ref/0x7f050019==0x7f0600a1]
            //editor.addResource("dimen", "testId2",Res_value.newFloat(0.3F));                  //添加Folat类型的值 样式[1050253696.000000==0.3]
            //editor.addResource("dimen", "testId3",Res_value.newDimension(0x00005f01,Res_value.UNIT_PX));                  //添加Folat类型的值 样式[1050253696.000000==0.3]


//            // 添加维度类型资源（例如：16dp）
//            editor.addResource("dimen", "test_dimen_1", Res_value.newDimension(0x00001001, Res_value.COMPLEX_UNIT_DIP));// 24dp
//            editor.addResource("dimen", "test_dimen_2", Res_value.newDimension(0x00001001, Res_value.COMPLEX_UNIT_SP)); // 24sp
//            editor.addResource("dimen", "test_dimen_3", Res_value.newDimension(0x00001001, Res_value.COMPLEX_UNIT_PX)); // 100px
//            editor.addResource("dimen", "test_dimen_4", Res_value.newDimension(0x00001001, Res_value.COMPLEX_UNIT_PT)); // 12pt
//            editor.addResource("dimen", "test_dimen_5", Res_value.newDecInt(0x00001001)); // 12pt
//
//
//            // 添加分数类型资源（例如：50%）
//            editor.addResource("fraction", "test_fraction_1", Res_value.newFraction(50, Res_value.FRACTION_FLAG_NORMAL));
//            editor.addResource("fraction", "test_fraction_2", Res_value.newFraction(50, Res_value.FRACTION_FLAG_PARENT));// 添加相对于父容器的分数（例如：50%p）

            editor.save2ApkFile("C:/Users/Administrator/Desktop/test/demo1.apk");
            //Res_value.newReference()
            editor.printArscInfo2();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}